{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "Neural Network Potentials.ipynb",
      "provenance": [],
      "collapsed_sections": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/google/jax-md/blob/master/notebooks/neural_networks.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "b7RYjwcysgZI"
      },
      "source": [
        "Copyright 2020 Google LLC\n",
        "\n",
        "Licensed under the Apache License, Version 2.0 (the \"License\");\n",
        "you may not use this file except in compliance with the License.\n",
        "You may obtain a copy of the License at\n",
        "\n",
        "     https://www.apache.org/licenses/LICENSE-2.0\n",
        "\n",
        "Unless required by applicable law or agreed to in writing, software\n",
        "distributed under the License is distributed on an \"AS IS\" BASIS,\n",
        "WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n",
        "See the License for the specific language governing permissions and\n",
        "limitations under the License."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KVIHud2diL51",
        "cellView": "form"
      },
      "source": [
        "#@title Imports & Utils\n",
        "!pip install -q git+https://www.github.com/deepmind/haiku\n",
        "!pip install -q git+https://www.github.com/deepmind/optax\n",
        "!pip install -q --upgrade git+https://www.github.com/google/jax-md\n",
        "\n",
        "# Imports\n",
        "\n",
        "import os\n",
        "import numpy as onp\n",
        "import pickle\n",
        "\n",
        "import jax\n",
        "from jax import lax\n",
        "\n",
        "from jax.api import jit, vmap, grad\n",
        "\n",
        "# TODO: Re-enable x64 mode after XLA bug fix.\n",
        "# from jax.config import config ; config.update('jax_enable_x64', True)\n",
        "import warnings\n",
        "warnings.simplefilter('ignore')\n",
        "import jax.numpy as np\n",
        "\n",
        "from jax import random\n",
        "\n",
        "import optax\n",
        "\n",
        "from jax_md import energy, space, simulate, quantity\n",
        "\n",
        "# Plotting.\n",
        "\n",
        "import matplotlib\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "import pylab as pl\n",
        "from IPython import display\n",
        "from functools import partial\n",
        "  \n",
        "sns.set_style(style='white')\n",
        "sns.set(font_scale=1.6)\n",
        "\n",
        "def format_plot(x, y):\n",
        "  plt.xlabel(x, fontsize=20)\n",
        "  plt.ylabel(y, fontsize=20)\n",
        "  \n",
        "def finalize_plot(shape=(1, 1)):\n",
        "  plt.gcf().set_facecolor('white')\n",
        "  plt.gcf().set_size_inches(\n",
        "    shape[0] * 1.5 * plt.gcf().get_size_inches()[1], \n",
        "    shape[1] * 1.5 * plt.gcf().get_size_inches()[1])\n",
        "  plt.tight_layout()\n",
        "\n",
        "def draw_training(params):\n",
        "  display.clear_output(wait=True)\n",
        "  display.display(plt.gcf())\n",
        "  plt.subplot(1, 2, 1)\n",
        "  plt.semilogy(train_energy_error)\n",
        "  plt.semilogy(test_energy_error)\n",
        "  plt.xlim([0, train_epochs])\n",
        "  format_plot('Epoch', '$L$')\n",
        "  plt.subplot(1, 2, 2)\n",
        "  predicted = vectorized_energy_fn(params, example_positions)\n",
        "  plt.plot(example_energies, predicted, 'o')\n",
        "  plt.plot(np.linspace(-400, -300, 10), np.linspace(-400, -300, 10), '--')\n",
        "  format_plot('$E_{label}$', '$E_{prediction}$')\n",
        "  finalize_plot((2, 1))\n",
        "  plt.show()\n",
        "\n",
        "# Data Loading.\n",
        "\n",
        "def MD_trajectory_reader(f, no_skip=20):\n",
        "  filename = os.path.join('Supplementary/', f)\n",
        "  fo = open(filename, 'r')\n",
        "  samples = fo.read().split('iter= ')[1:]\n",
        "  steps = []\n",
        "  lattice_vectors = []\n",
        "  positions = []\n",
        "  forces = []\n",
        "  temperatures = []\n",
        "  energies = []\n",
        "  for sample in samples[::no_skip]:\n",
        "    entries = sample.split('\\n')\n",
        "    steps.append(int(entries[0]))\n",
        "    lattice_vectors.append(onp.array([list(map(float, lv.split())) for lv in entries[1:4]]))\n",
        "    assert entries[4]=='64'\n",
        "    temp = onp.array([list(map(float, lv.split()[1:])) for lv in entries[5:69]])\n",
        "    positions.append(temp[:,:3])\n",
        "    forces.append(temp[:,3:])\n",
        "    remaining_lines = entries[69:]\n",
        "    temperatures.append(float([entry for entry in entries[69:] if 'Temp' in entry ][0].split('=')[1].split()[0]))\n",
        "    energies.append(float([entry for entry in entries[69:] if 'el-ion E' in entry ][0].split('=')[1].split()[0]))\n",
        "  assert (len(set(steps))-(steps[-1]-steps[0]+1)/no_skip) < 1\n",
        "  return np.array(positions), np.array(energies), np.array(forces)\n",
        "\n",
        "def build_dataset():\n",
        "  no_skip = 15\n",
        "  data300, energies300, forces300 = MD_trajectory_reader(\n",
        "      'MD_DATA.cubic_300K', no_skip=no_skip)\n",
        "  data600, energies600, forces600 = MD_trajectory_reader(\n",
        "      'MD_DATA.cubic_600K', no_skip=no_skip)\n",
        "  data900, energies900, forces900 = MD_trajectory_reader(\n",
        "      'MD_DATA.cubic_900K', no_skip=no_skip)\n",
        "  dataliq, energiesliq, forcesliq = MD_trajectory_reader(\n",
        "      'MD_DATA.liq_1', no_skip=no_skip)\n",
        "\n",
        "  all_data = np.vstack((data300, data600, data900))\n",
        "  all_energies = np.hstack((energies300, energies600, energies900))\n",
        "  all_forces = np.vstack((forces300, forces600, forces900))\n",
        "  noTotal = all_data.shape[0]\n",
        "\n",
        "  onp.random.seed(0)\n",
        "  II = onp.random.permutation(range(noTotal))\n",
        "  all_data = all_data[II]\n",
        "  all_energies = all_energies[II]\n",
        "  all_forces = all_forces[II]\n",
        "  noTr = int(noTotal * 0.65)\n",
        "  noTe = noTotal - noTr\n",
        "  train_data = all_data[:noTr]\n",
        "  test_data = all_data[noTr:]\n",
        "\n",
        "  train_energies = all_energies[:noTr]\n",
        "  test_energies = all_energies[noTr:]\n",
        "\n",
        "  train_forces = all_forces[:noTr]\n",
        "  test_forces = all_forces[noTr:]\n",
        "\n",
        "  return ((train_data, train_energies, train_forces),\n",
        "          (test_data, test_energies, test_forces))"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "muBsYny61Gbv"
      },
      "source": [
        "# Neural Network Potentials"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3gjTwTSvvozm"
      },
      "source": [
        "An area of significant recent interest is the use of neural networks to model quantum mechanics. Since directly (or approximately) solving Schrodinger's equation is extremely expensive, these techniques offers the tantalizing possibility of conducting large-scale and high-fidelity experiments of materials as well as chemical and biochemical systems. \n",
        "\n",
        "\\\n",
        "\n",
        "Usually, neural networks are fit to energies computed from Density Functional Theory (DFT). DFT is a ubiquitous *ab initio* formalism for approximating solutions to Schrodinger's equation. It offers a balance between accuracy and speed; DFT is much faster than more precise solutions to quantum systems, but is fast enough to use on systems of hundreds of atoms. Nonetheless, DFT calculations scale as $\\mathcal O(N^3)$ and so they are prohibitively expensive to run on large systems or for long simulation trajectories. \n",
        "\n",
        "\\\n",
        "\n",
        "As with many areas of machine learning, early efforts to fit quantum mechanical interactions with neural networks relied on fixed feature methods with shallow neural network potentials. Lately, however, these networks have been replaced by deeper graph neural network architectures that learn salient features. JAX MD includes both popular fixed-feature methods as well as graph neural networks. \n",
        "\n",
        "\\\n",
        "\n",
        "Here we will use JAX MD to fit a state-of-the-art graph neural network to open-source DFT data from a 64-atom Silicon system that accompanied a [recent paper](https://aip.scitation.org/doi/10.1063/1.4990503). This Silicon system was simulated at several different temperatures. We will uniformly sample data from these trajectories to construct training and test sets. We will follow modern best-practices and fit to both energies and forces computed using DFT. We will then use this network to run a simulation using JAX MDs simulation environments. To start with we first download the data. This might take a little a minute or two."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZgP6T5VV3wSn",
        "cellView": "form"
      },
      "source": [
        "#@title Download Data\n",
        "\n",
        "!wget https://aip.scitation.org/doi/suppl/10.1063/1.4990503/suppl_file/supplementary.zip\n",
        "!wget https://github.com/google/jax-md/blob/master/examples/models/si_gnn.pickle?raw=true\n",
        "!unzip supplementary.zip"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pjbaj79a4Av4"
      },
      "source": [
        "We will then load the data using a small utility function into training and test sets. Each split will include particle positions, whole-system energies, and per-particle forces. To assist in training we will compute the mean and standard deviation of the data and use this to set the initial scale for our neural network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dNIar1gB3zig",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "90b76026-e52c-447a-adbe-627c50f12905"
      },
      "source": [
        "train, test = build_dataset()\n",
        "\n",
        "positions, energies, forces = train\n",
        "test_positions, test_energies, test_forces = test\n",
        "\n",
        "energy_mean = np.mean(energies)\n",
        "energy_std = np.std(energies)\n",
        "\n",
        "print('positions.shape = {}'.format(positions.shape))\n",
        "print('<E> = {}'.format(energy_mean))"
      ],
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "positions.shape = (2416, 64, 3)\n",
            "<E> = -368.9131164550781\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Kib1B2Mm4yRp"
      },
      "source": [
        "Next we create a space for our systems to live in using `periodic` boundary conditions."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nMzMGNf0463Y"
      },
      "source": [
        "box_size = 10.862  # The size of the simulation region.\n",
        "displacement, shift = space.periodic(box_size)"
      ],
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WNs8v2745Mc3"
      },
      "source": [
        "We can now instantiate a graph neural network using the `energy.graph_network_neighbor_list` command. This neural network is based on [recent work](https://www.nature.com/articles/s41567-020-0842-8) modelling defects in disordered solids. See that paper or the review by [Battaglia et al.](https://arxiv.org/abs/1806.01261) for details. We will add edges between all neighbors that are separated by less than a cutoff of 3 Angstroms. In JAX MD neural network potentials are specified by a triple of functions: a `neighbor_fn` that creates a list of neighbors that reside within the cutoff, an `init_fn` that initializes the parameters of the network, and an `energy_fn` that evaluates the model."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Fu4RvlXU5Cwb"
      },
      "source": [
        "neighbor_fn, init_fn, energy_fn = energy.graph_network_neighbor_list(\n",
        "    displacement, box_size, r_cutoff=3.0, dr_threshold=0.0)"
      ],
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BLF5A-D96jDU"
      },
      "source": [
        "To start with, we construct an initial neighbor list which will be used to estimate the maximum number of neighbors. This is necessary since XLA needs to have static shapes to enable JIT compilation. See [here](https://github.com/google/jax-md#spatial-partitioning-partitionpy) for details."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FzcabwoM6iiN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e8b503b3-4bab-4964-811e-be6d2625afd7"
      },
      "source": [
        "neighbor = neighbor_fn(positions[0], extra_capacity=6)\n",
        "\n",
        "print('Allocating space for at most {} neighbors'.format(neighbor.idx.shape[1]))"
      ],
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Allocating space for at most 14 neighbors\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "t2pWF0jE_Ha4"
      },
      "source": [
        "Using this neighbor prototype we will write a wrapper around our neural network energy function that will construct a neighbor list for a given state and then compute the energy. This is helpful because it allows us to use JAX's automatic vectorization via `vmap` along with our neighbor lists. Using JAX's automatic differentiation we can also write down a function that computes the force due to our neural network potential.\n",
        "\n",
        "Note that if we were running a simulation using this energy, we would only rebuild the neighbor list when necessary."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CZVtIaMs_3IY"
      },
      "source": [
        "@jit\n",
        "def train_energy_fn(params, R):\n",
        "  _neighbor = neighbor_fn(R, neighbor)\n",
        "  return energy_fn(params, R, _neighbor)\n",
        "\n",
        "# Vectorize over states, not parameters.\n",
        "vectorized_energy_fn = vmap(train_energy_fn, (None, 0))\n",
        "\n",
        "grad_fn = grad(train_energy_fn, argnums=1)\n",
        "force_fn = lambda params, R, **kwargs: -grad_fn(params, R)\n",
        "vectorized_force_fn = vmap(force_fn, (None, 0))"
      ],
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "R3MvxVtj-SUQ"
      },
      "source": [
        "Next we will initialize the parameters of the graph network. This is done by providing the `init_fn` with a random key as well as an example input. As with the neighbor lists, this example input is used to deduce the shape of the various parameters."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dhnKug1_-MPS"
      },
      "source": [
        "key = random.PRNGKey(0)\n",
        "\n",
        "params = init_fn(key, positions[0], neighbor)"
      ],
      "execution_count": 8,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1H2wGxzg-tJv"
      },
      "source": [
        "Now, we can use JAX's automatic vectorization via `vmap` to compute predicted energies for all of the states using the untrained network."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ns5oB-gN-n9P"
      },
      "source": [
        "n_predictions = 500\n",
        "example_positions = positions[:n_predictions]\n",
        "example_energies = energies[:n_predictions]\n",
        "example_forces = forces[:n_predictions]\n",
        "\n",
        "predicted = vmap(train_energy_fn, (None, 0))(params, example_positions)"
      ],
      "execution_count": 9,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BP6x1sEPAY_A",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 441
        },
        "outputId": "32637803-758e-4750-a2bf-aac3f96a6c0a"
      },
      "source": [
        "plt.plot(example_energies, predicted, 'o')\n",
        "\n",
        "format_plot('$E_{label}$', '$E_{predicted}$')\n",
        "\n",
        "finalize_plot((1, 1))"
      ],
      "execution_count": 10,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 432x432 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Q55oI3EAAeyN"
      },
      "source": [
        "Despite the fact that the neural network is untrained we see that the outputs of the graph network correlate strongly with the labels. This hints that perhaps graph networks provide some sort of \"deep molecular prior\". \n",
        "\n",
        "Next, we define losses for the energy and the force as well as a total loss that combines the two terms. We fit both the force and the energy using Mean-Squared-Error (MSE) loss."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pwxERR68AeoB"
      },
      "source": [
        "@jit\n",
        "def energy_loss(params, R, energy_targets):\n",
        "  return np.mean((vectorized_energy_fn(params, R) - energy_targets) ** 2)\n",
        "\n",
        "@jit\n",
        "def force_loss(params, R, force_targets):\n",
        "  dforces = vectorized_force_fn(params, R) - force_targets\n",
        "  return np.mean(np.sum(dforces ** 2, axis=(1, 2)))\n",
        "\n",
        "@jit\n",
        "def loss(params, R, targets):\n",
        "  return energy_loss(params, R, targets[0]) + force_loss(params, R, targets[1])"
      ],
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "seSkwLZqBIrK"
      },
      "source": [
        "Now we create an optimizer using ADAM with gradient clipping. We will also write helper functions to perform a single update step and perform an entire epochs worth of updates."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xhgLDCFSAcdI"
      },
      "source": [
        "opt = optax.chain(optax.clip_by_global_norm(1.0),\n",
        "                  optax.adam(1e-3))\n",
        "\n",
        "@jit\n",
        "def update_step(params, opt_state, R, labels):\n",
        "  updates, opt_state = opt.update(grad(loss)(params, R, labels),\n",
        "                                  opt_state)\n",
        "  return optax.apply_updates(params, updates), opt_state\n",
        "\n",
        "@jit\n",
        "def update_epoch(params_and_opt_state, batches):\n",
        "  def inner_update(params_and_opt_state, batch):\n",
        "    params, opt_state = params_and_opt_state\n",
        "    b_xs, b_labels = batch\n",
        "\n",
        "    return update_step(params, opt_state, b_xs, b_labels), 0\n",
        "  return lax.scan(inner_update, params_and_opt_state, batches)[0]"
      ],
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BHkWBfh7CHGt"
      },
      "source": [
        "Finally, we will write a function that creates an epoch's worth of batches given a lookup table that shuffles all of the states in the training set."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "We1uelXUBaXj"
      },
      "source": [
        "dataset_size = positions.shape[0]\n",
        "batch_size = 128\n",
        "\n",
        "lookup = onp.arange(dataset_size)\n",
        "onp.random.shuffle(lookup)\n",
        "\n",
        "@jit\n",
        "def make_batches(lookup):\n",
        "  batch_Rs = []\n",
        "  batch_Es = []\n",
        "  batch_Fs = []\n",
        "\n",
        "  for i in range(0, len(lookup), batch_size):\n",
        "    if i + batch_size > len(lookup):\n",
        "      break\n",
        "\n",
        "    idx = lookup[i:i + batch_size]\n",
        "\n",
        "    batch_Rs += [positions[idx]]\n",
        "    batch_Es += [energies[idx]]\n",
        "    batch_Fs += [forces[idx]]\n",
        "\n",
        "  return np.stack(batch_Rs), np.stack(batch_Es), np.stack(batch_Fs)\n",
        "\n",
        "batch_Rs, batch_Es, batch_Fs = make_batches(lookup)"
      ],
      "execution_count": 13,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MZCqMAUvCVS6"
      },
      "source": [
        "We're now ready to train our network. We'll start by training for twenty epochs to make sure it starts training."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DrmKVE6lCQz_",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 458
        },
        "outputId": "b49bfe43-37e3-4122-cbcf-cf269563381a"
      },
      "source": [
        "train_epochs = 20\n",
        "\n",
        "opt_state = opt.init(params)\n",
        "\n",
        "train_energy_error = []\n",
        "test_energy_error = []\n",
        "\n",
        "for iteration in range(train_epochs):\n",
        "  train_energy_error += [float(np.sqrt(energy_loss(params, batch_Rs[0], batch_Es[0])))]\n",
        "  test_energy_error += [float(np.sqrt(energy_loss(params, test_positions, test_energies)))]\n",
        " \n",
        "  draw_training(params)\n",
        "\n",
        "  params, opt_state = update_epoch((params, opt_state), \n",
        "                                   (batch_Rs, (batch_Es, batch_Fs)))\n",
        "\n",
        "  onp.random.shuffle(lookup)\n",
        "  batch_Rs, batch_Es, batch_Fs = make_batches(lookup)"
      ],
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 0 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MV-qtMJsD6s7"
      },
      "source": [
        "While we see that the network has begun to learn the energies, we also see that it has a long way to go before the predictions get good enough to use in a simulation. As such we're going to take inspiration from cooking shows, and take a ready-made GNN out of the fridge where it has been training overnight for 12,000 epochs on a V100 GPU."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e89weTfODSDz"
      },
      "source": [
        "with open('si_gnn.pickle?raw=true', 'rb') as f:\n",
        "  params = pickle.load(f)"
      ],
      "execution_count": 15,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KiYDpSSVGR0l"
      },
      "source": [
        "Using our trained model we plot the predicted energies and forces against the labels. "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4j0Zz0RDEUVF",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 441
        },
        "outputId": "f1bfe858-5cda-4724-f973-19106361751c"
      },
      "source": [
        "plt.subplot(1, 2, 1)\n",
        "\n",
        "predicted_energies = vectorized_energy_fn(params, example_positions)\n",
        "plt.plot(example_energies, predicted_energies, 'o')\n",
        "\n",
        "format_plot('$E_{label}$', '$E_{predicted}$')\n",
        "plt.subplot(1, 2, 2)\n",
        "\n",
        "predicted_forces = vectorized_force_fn(params, test_positions[:300])\n",
        "plt.plot(test_forces[:300].reshape((-1,)),\n",
        "         predicted_forces.reshape((-1,)), \n",
        "         'o')\n",
        "plt.plot(np.linspace(-6, 6, 20), np.linspace(-6, 6, 20), '--')\n",
        "plt.xlim([-5, 5])\n",
        "plt.ylim([-5, 5])\n",
        "\n",
        "format_plot('$F_{label}$', '$F_{predicted}$')\n",
        "finalize_plot((2, 1))"
      ],
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 864x432 with 2 Axes>"
            ]
          },
          "metadata": {
            "tags": []
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "CEHy6mb-GtHp"
      },
      "source": [
        "We see that the model prediction for the energy is extremely accurate and the force prediction is reasonable. To make this a bit more quantitative, we can compute the RMSE of the energy and convert it to meV / atom."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JMTkHZ9uGrES",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a5331c6f-d930-491d-f902-bc8a05e5f4e5"
      },
      "source": [
        "rmse = energy_loss(params, test_positions, test_energies) * 1000 / 64\n",
        "print('RMSE Error of {:.02f} meV / atom'.format(rmse))"
      ],
      "execution_count": 17,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "RMSE Error of 0.57 meV / atom\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kw14TB9YHovL"
      },
      "source": [
        "We see that we get an error of about $2$ meV / atom, which is comparable to previous work on this system.\n",
        "\n",
        "Now that we have a well-performing neural network, we can see how easily this network can be used to run a simulation approximating Silicon. We will run a constant temperature simulation using a Nose-Hoover thermostat. First, we \"bake\" the params into the energy function using partial evaluation."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-5pfEq6YHFxd"
      },
      "source": [
        "E_fn = partial(energy_fn, params)"
      ],
      "execution_count": 18,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "J92Mr9OvI5ME"
      },
      "source": [
        "Then, we setup the parameters of the simulation and create the simulation environment."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zLQjf50qI2Ed"
      },
      "source": [
        "K_B = 8.617e-5\n",
        "dt = 1e-3\n",
        "kT = K_B * 300 \n",
        "Si_mass = 2.91086E-3\n",
        "\n",
        "init_fn, apply_fn = simulate.nvt_nose_hoover(E_fn, shift, dt, kT)\n",
        "\n",
        "apply_fn = jit(apply_fn)"
      ],
      "execution_count": 19,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uzt4iy2JJACQ"
      },
      "source": [
        "Finally we run the simulation for 10000 steps while writing the energy and temperature throughout."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pXpsLlnXI9K5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0c3ac8c3-4f77-4ecd-9a5a-954289f5407e"
      },
      "source": [
        "# Define the simulation.\n",
        "total_steps = 10000\n",
        "steps_per_recording = 25\n",
        "total_records = total_steps // steps_per_recording\n",
        "\n",
        "positions = []\n",
        "\n",
        "@jit\n",
        "def sim(state, nbrs):\n",
        "  def step(i, state_nbrs):\n",
        "    state, nbrs = state_nbrs\n",
        "    nbrs = neighbor_fn(state.position, nbrs)\n",
        "    return apply_fn(state, neighbor=nbrs), nbrs\n",
        "  return lax.fori_loop(0, steps_per_recording, step, (state, nbrs))\n",
        "\n",
        "\n",
        "# Initialize the simulation\n",
        "\n",
        "nbrs = neighbor_fn(test_positions[0])\n",
        "state = init_fn(key, test_positions[0], Si_mass, neighbor=nbrs)\n",
        "\n",
        "\n",
        "# Run the simulation.\n",
        "\n",
        "print('Energy (eV)\\tTemperature (K)')\n",
        "for i in range(total_records):\n",
        "  state, nbrs = sim(state, nbrs)\n",
        "\n",
        "  positions += [state.position]\n",
        "\n",
        "  if i % 40 == 0:\n",
        "    print('{:.02f}\\t\\t\\t{:.02f}'.format(\n",
        "        E_fn(state.position, neighbor=nbrs),\n",
        "        quantity.temperature(state.velocity, Si_mass) / K_B))\n",
        "\n",
        "positions = np.stack(positions)"
      ],
      "execution_count": 20,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Energy (eV)\tTemperature (K)\n",
            "-375.11\t\t\t252.24\n",
            "-378.97\t\t\t359.84\n",
            "-378.57\t\t\t272.46\n",
            "-378.42\t\t\t306.72\n",
            "-378.69\t\t\t272.91\n",
            "-378.35\t\t\t305.10\n",
            "-379.12\t\t\t341.76\n",
            "-378.87\t\t\t295.63\n",
            "-378.55\t\t\t317.24\n",
            "-378.97\t\t\t296.28\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "XbpisZHBKIOP"
      },
      "source": [
        "We see that the energy of the simulation is reasonable and the temperature is stable. Of course, if we were validating this model for use in a research setting there are many measurements that one would like to perform to check its fidelity.\n",
        "\n",
        "We can now draw the simulation to see what is happening."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WYxLhxrUjcB7"
      },
      "source": [
        "from jax_md.colab_tools import renderer\n",
        "\n",
        "nbrs = neighbor_fn(state.position)\n",
        "\n",
        "renderer.render(box_size,\n",
        "                {\n",
        "                    'atom': renderer.Sphere(positions),\n",
        "                    'bonds': renderer.Bond('atom', nbrs.idx),\n",
        "                },\n",
        "                resolution=[512, 512])"
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}